
// // 自定义日志回调函数
// void ffmpeg_android_log(void *ptr, int level, const char *fmt, va_list vl) {
//   // 映射 FFmpeg 日志级别到 Android 级别
//   int android_level;
//   switch (level) {
//     case AV_LOG_PANIC:
//     case AV_LOG_FATAL:
//       android_level = ANDROID_LOG_FATAL;
//       break;
//     case AV_LOG_ERROR:
//       android_level = ANDROID_LOG_ERROR;
//       break;
//     case AV_LOG_WARNING:
//       android_level = ANDROID_LOG_WARN;
//       break;
//     case AV_LOG_INFO:
//       android_level = ANDROID_LOG_INFO;
//       break;
//     case AV_LOG_VERBOSE:
//     case AV_LOG_DEBUG:
//     case AV_LOG_TRACE:
//     default:
//       android_level = ANDROID_LOG_DEBUG;
//   }

//   // 格式化日志消息
//   char buffer[512];
//   vsnprintf(buffer, sizeof(buffer), fmt, vl);

//   // 输出到 Android logcat
//   __android_log_print(android_level, "FFmpeg/Native", "%s", buffer);
// }

// // 在初始化代码中设置
// void init_ffmpeg_logging() {
//   // 设置日志级别（DEBUG 包含所有信息）
//   av_log_set_level(AV_LOG_WARNING);

//   // 注册自定义回调
//   av_log_set_callback(ffmpeg_android_log);
// }

// int Parse::playVideo(int fd) {
//   // 设置日志级别（调试时建议使用AV_LOG_DEBUG）
//   // 设置日志级别（DEBUG 包含所有信息）
//   // init_ffmpeg_logging();
//   __android_log_print(ANDROID_LOG_INFO, "EGL", "playVideo %d", fd);

//   AVIOContext *avio_ctx =
//       avio_alloc_context((unsigned char *)av_malloc(4096),  // 缓冲区
//                          4096,                              // 缓冲区大小
//                          0,            // 写标志（0=只读）
//                          &fd,          // 透传参数
//                          read_packet,  // 读回调
//                          NULL,         // 写回调（不需要）
//                          seek_packet   // seek 回调
//       );
//   AVFormatContext *format_ctx = nullptr;
//   AVPacket *pkt = nullptr;
//   AVFrame *frame = nullptr;
//   AVCodecContext *codecCtx = nullptr;
//   const AVCodec *codec = nullptr;
//   int ret = 0;
//   int video_stream_index = 0;
//   int audio_stream = 0;
//   // 初始化FFmpeg库
//   avformat_network_init();  // 支持网络流
//   format_ctx = avformat_alloc_context();
//   format_ctx->pb = avio_ctx;  // 关键！绑定自定义 IO

//   // 1. 打开输入文件
//   if ((ret = avformat_open_input(&format_ctx, nullptr, nullptr, nullptr)) !=
//       0) {
//     char errBuf[AV_ERROR_MAX_STRING_SIZE];
//     av_strerror(ret, errBuf, sizeof(errBuf));
//     return -1;
//   }

//   // 2. 获取流信息
//   if ((ret = avformat_find_stream_info(format_ctx, nullptr)) < 0) {
//     avformat_close_input(&format_ctx);
//     return -1;
//   }

//   // 查找视频流
//   for (unsigned i = 0; i < format_ctx->nb_streams;
//        ++i) {  // nb_streams 是流的数量（视频流、音频流、字幕流）
//     if (format_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
//       video_stream_index = i;
//     }
//     if (format_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
//       audio_stream = i;
//     }
//   }

//   if (video_stream_index == -1) {
//     return false;
//   }

//   // 优先尝试查找MediaCodec硬件解码器
//   // const char *hw_decoder_name = nullptr;
//   // switch (format_ctx->streams[video_stream_index]->codecpar->codec_id)
//   // {
//   // case AV_CODEC_ID_H264:
//   //     hw_decoder_name = "h264_mediacodec"; // H.264硬件解码器
//   //     break;
//   // case AV_CODEC_ID_HEVC:
//   //     hw_decoder_name = "hevc_mediacodec"; // H.265硬件解码器
//   //     break;
//   // case AV_CODEC_ID_VP8:
//   //     hw_decoder_name = "vp8_mediacodec";
//   //     break;
//   // case AV_CODEC_ID_VP9:
//   //     hw_decoder_name = "vp9_mediacodec";
//   //     break;
//   // default:
//   //     hw_decoder_name = nullptr;
//   // }
//   // __android_log_print(ANDROID_LOG_INFO, TAG_.c_str(), "hw_decoder_name:%s
//   ",
//   // hw_decoder_name);
//   // // 1. 优先尝试硬件解码器
//   // const AVCodec *avcodec = nullptr;
//   // if (hw_decoder_name)
//   // {
//   //     avcodec = avcodec_find_decoder_by_name(hw_decoder_name);
//   // }
//   const AVCodec *avcodec = nullptr;
//   // 2. 硬件解码器未找到时回退到软件解码器
//   if (!avcodec) {
//     avcodec = avcodec_find_decoder(
//         format_ctx->streams[video_stream_index]->codecpar->codec_id);
//   }
//   if (!avcodec) {
//     return false;
//   }

//   // 为指定的编码器codec分配初始化一个编解码器上下文，但只是空白框架
//   AVCodecContext *codec_ctx = avcodec_alloc_context3(avcodec);
//   if (!codec_ctx) {
//     return false;
//   }

//   // 先复制编解码器参数
//   if (avcodec_parameters_to_context(
//           codec_ctx, format_ctx->streams[video_stream_index]->codecpar) < 0)
//           {
//     return false;
//   }

//   // 再设置硬件设备
//   // AVBufferRef *hw_device_ctx = nullptr;
//   // if (int ret1 = av_hwdevice_ctx_create(&hw_device_ctx,
//   // AV_HWDEVICE_TYPE_MEDIACODEC, nullptr, 0, 0) >= 0)
//   // {
//   //     __android_log_print(ANDROID_LOG_INFO, "test1",
//   "av_hwdevice_ctx_create
//   //     success %d", ret1); codec_ctx->hw_device_ctx =
//   //     av_buffer_ref(hw_device_ctx);
//   // }

//   // 继续初始化编解码器参数
//   if (avcodec_open2(codec_ctx, avcodec, nullptr) < 0) {
//     return false;
//   }

//   // AVPixelFormat original_pix_fmt = codec_ctx->pix_fmt; // 输出原始像素格式
//   //
//   分配AVFrame，用于存储解码后的帧数据的各种信息（图像像素数据、宽高、时间戳等）
//   frame = av_frame_alloc();
//   if (!frame) {
//     av_frame_free(&frame);
//     avcodec_free_context(&codec_ctx);
//     avformat_close_input(&format_ctx);
//   }
//   // 初始化创建一个图像缩放和颜色空间转换的上下文 SwsContext
//   // struct SwsContext *sws_ctx = sws_getContext(codec_ctx->width,
//   // codec_ctx->height, codec_ctx->pix_fmt,
//   //                                             codec_ctx->width,
//   //                                             codec_ctx->height,
//   //                                             AV_PIX_FMT_RGB24,
//   SWS_BILINEAR,
//   //                                             nullptr, nullptr, nullptr);
//   // if (!sws_ctx)
//   // {
//   //     av_frame_free(&frame);
//   //     avcodec_free_context(&codec_ctx);
//   //     avformat_close_input(&format_ctx);
//   // }

//   // AVPacket：存储的是压缩编码的数据包（视频流、音频流等都有可能）
//   // 一个AVPacket可能对应多个AVFrame
//   AVPacket packet;
//   int64_t previous_pts = 0;
//   // 调用eglMakeCurrent后立即检查状态
//   EGLBoolean success =
//       eglMakeCurrent(playManager_->display, playManager_->surface,
//                      playManager_->surface, playManager_->context);

//   while (av_read_frame(format_ctx, &packet) >= 0) {
//     auto start_time = std::chrono::high_resolution_clock::now();
//     if (packet.stream_index == video_stream_index) {  // 只拿视频流
//       if (avcodec_send_packet(codec_ctx, &packet) <
//           0) {  // 发送原始数据包,并不会立即解码，而是放到输入缓冲区
//         av_packet_unref(&packet);  // 释放 packet
//         中的所有动态分配的内存和资源 continue;
//       }
//       int cycle_count = 0;
//       while (avcodec_receive_frame(codec_ctx, frame) ==
//              0) {  // 解码，一个packet可能对应多个frame帧
//                    // frame_number++
//         if (frame->width != codec_ctx->width ||
//             frame->height != codec_ctx->height) {
//           return false;
//         }
//         if (packet.data == nullptr || packet.size <= 0) {
//           return false;
//         }
//         // 交换缓冲区
// int64_t pts = frame->pts;  // 根据视频参数设置播放速率
// double frame_delay =
//     av_q2d(format_ctx->streams[video_stream_index]->time_base) *
//     (pts - previous_pts);
// previous_pts = pts;
// auto target_time =
//     start_time +
//     std::chrono::microseconds(static_cast<long>(frame_delay * 1e6));
// auto usetime =
//     std::chrono::duration_cast<std::chrono::microseconds>(
//         std::chrono::high_resolution_clock::now() - start_time)
//         .count();
// auto diff = frame_delay * 1e6 - static_cast<double>(usetime);
// if (diff > 1000) {
//   std::this_thread::sleep_for(
//       std::chrono::microseconds(static_cast<int>(diff)));
// }
// start_time = std::chrono::high_resolution_clock::now();
//       }
//       av_packet_unref(&packet);
//     }
//   }

//   return 0;
// }

// static aaudio_data_callback_result_t audioCallback(AAudioStream *stream,
//                                                    void *userData,
//                                                    void *audioData,
//                                                    int32_t numFrames) {
//   auto *buffer = static_cast<AudioBuffer *>(userData);
//   float *output = static_cast<float *>(audioData);
//   const int channels = AAudioStream_getChannelCount(stream);
//   const int totalSamples = numFrames * channels;

//   size_t read = buffer->read(output, totalSamples);

//   // 处理数据不足
//   if (read < totalSamples) {
//     memset(output + read, 0, (totalSamples - read) * sizeof(float));

//     // 检查是否解码完成且无数据
//     if (buffer->is_decoding_finished() && read == 0) {
//       return AAUDIO_CALLBACK_RESULT_STOP;
//     }
//   }

//   return AAUDIO_CALLBACK_RESULT_CONTINUE;
// }
// int Parse::playAudio(int fd) {
//   __android_log_print(ANDROID_LOG_INFO, "EGL", "playAudio %d", fd);
//   AVIOContext *avio_ctx =
//       avio_alloc_context((unsigned char *)av_malloc(4096),  // 缓冲区
//                          4096,                              // 缓冲区大小
//                          0,            // 写标志（0=只读）
//                          &fd,          // 透传参数
//                          read_packet,  // 读回调
//                          NULL,         // 写回调（不需要）
//                          seek_packet   // seek 回调
//       );
//   AVFormatContext *format_ctx = nullptr;
//   int ret = 0;
//   int audio_stream = 0;
//   // 初始化FFmpeg库
//   avformat_network_init();  // 支持网络流
//   format_ctx = avformat_alloc_context();
//   format_ctx->pb = avio_ctx;  // 关键！绑定自定义 IO

//   // 1. 打开输入文件
//   if ((ret = avformat_open_input(&format_ctx, nullptr, nullptr, nullptr)) !=
//       0) {
//     char errBuf[AV_ERROR_MAX_STRING_SIZE];
//     av_strerror(ret, errBuf, sizeof(errBuf));
//     return -1;
//   }

//   // 2. 获取流信息
//   if ((ret = avformat_find_stream_info(format_ctx, nullptr)) < 0) {
//     avformat_close_input(&format_ctx);
//     return -1;
//   }

//   // 查找音频流
//   for (unsigned i = 0; i < format_ctx->nb_streams; ++i) {
//     if (format_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
//       audio_stream = i;
//     }
//   }

//   const AVCodec *avcodec = nullptr;
//   if (!avcodec) {
//     avcodec = avcodec_find_decoder(
//         format_ctx->streams[audio_stream]->codecpar->codec_id);
//   }
//   if (!avcodec) {
//     return false;
//   }

//   // 为指定的编码器codec分配初始化一个编解码器上下文，但只是空白框架
//   AVCodecContext *codec_ctx = avcodec_alloc_context3(avcodec);
//   if (!codec_ctx) {
//     return false;
//   }

//   // 先复制编解码器参数
//   if (avcodec_parameters_to_context(
//           codec_ctx, format_ctx->streams[audio_stream]->codecpar) < 0) {
//     return false;
//   }

//   // 继续初始化编解码器参数
//   if (avcodec_open2(codec_ctx, avcodec, nullptr) < 0) {
//     return false;
//   }

//   AVChannelLayout out_ch_layout = AV_CHANNEL_LAYOUT_STEREO;  // 输出声道布局
//   SwrContext *swrCtx = nullptr;
//   swr_alloc_set_opts2(&swrCtx,
//                       &out_ch_layout,  // 输出布局
//                       AV_SAMPLE_FMT_FLT,
//                       codec_ctx->sample_rate,  // 输出采样率
//                       &codec_ctx->ch_layout,   // 输入布局
//                       codec_ctx->sample_fmt,   // 输入格式
//                       codec_ctx->sample_rate,  // 输入采样率
//                       0, nullptr);
//   swr_init(swrCtx);
//   int out_channels = out_ch_layout.nb_channels;
//   AAudioStreamBuilder *builder;
//   AAudio_createStreamBuilder(&builder);
//   AAudioStreamBuilder_setDirection(builder, AAUDIO_DIRECTION_OUTPUT);
//   AAudioStreamBuilder_setSampleRate(
//       builder, codec_ctx->sample_rate);  // 使用解码器采样率
//   AAudioStreamBuilder_setChannelCount(builder, out_channels);  // 动态声道数
//   AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_FLOAT);  //
//   浮点格式 AAudioStreamBuilder_setPerformanceMode(builder,
//                                          AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
//   AAudioStreamBuilder_setDataCallback(builder, audioCallback, &pcm_buffer);

//   // 启动音频流
//   AAudioStream *stream;
//   aaudio_result_t result = AAudioStreamBuilder_openStream(builder, &stream);
//   if (result != AAUDIO_OK) {
//     // 错误处理
//     return -1;
//   }
//   AAudioStream_requestStart(stream);
//   AVPacket *packet = av_packet_alloc();
//   AVFrame *frame = av_frame_alloc();
//   int count = 0;
//   while ((ret = av_read_frame(format_ctx, packet)) >= 0) {
//     if (packet->stream_index == audio_stream) {
//       // 发送数据包
//       int send_ret = avcodec_send_packet(codec_ctx, packet);
//       if (send_ret < 0) {
//         continue;
//       }
//       // 接收并处理所有解码帧
//       while (true) {
//         av_frame_unref(frame);  // 关键：重置帧状态
//         int recv_ret = avcodec_receive_frame(codec_ctx, frame);
//         // 处理接收状态
//         if (recv_ret == AVERROR(EAGAIN) || recv_ret == AVERROR_EOF) {
//           __android_log_print(ANDROID_LOG_DEBUG, "fhq", "recv_ret：%d",
//                               recv_ret);
//           break;  // 需要新数据或结束
//         } else if (recv_ret < 0) {
//           __android_log_print(ANDROID_LOG_DEBUG, "fhq", "recv_ret：%d",
//                               recv_ret);
//           break;
//         }
//         // ==== 重采样核心部分 ====
//         // 计算输出样本数（带错误检查）
// int outSamples = swr_get_out_samples(swrCtx, frame->nb_samples);
// if (outSamples < 0) {
//   continue;
// }

// // 使用 av_samples_alloc 分配单缓冲区
// uint8_t *audioBuf = nullptr;  // 单缓冲区指针
// int linesize;
// int alloc_ret = av_samples_alloc(&audioBuf,     // 输出缓冲区指针
//                                  &linesize,     // 输出行大小
//                                  out_channels,  // 输出声道数
//                                  outSamples,    // 每通道样本数
//                                  AV_SAMPLE_FMT_FLT,
//                                  0  // 对齐方式(0=默认)
// );

// if (alloc_ret < 0) {
//   continue;
// }

// // 创建指针数组用于swr_convert（交错格式只需第一个指针）
// uint8_t *audioData[1] = {audioBuf};  // 单元素指针数组

// // 执行重采样转换
// int realSamples =
//     swr_convert(swrCtx,
//                 audioData,                      // 输出缓冲区数组
//                 outSamples,                     // 输出容量
//                 (const uint8_t **)frame->data,  // 输入数据
//                 frame->nb_samples);

// if (realSamples < 0) {
//   av_freep(&audioBuf);  // 安全释放内存
//   continue;
// }
// const float *floatData = reinterpret_cast<float *>(audioBuf);
// __android_log_print(ANDROID_LOG_DEBUG, "fhq", "write: %lf",
//                     floatData[0]);
// count++;
// int total_samples = realSamples * out_channels;
// pcm_buffer.write(floatData, total_samples);
//         av_freep(&audioBuf);  // 使用av_freep避免悬空指针
//       }
//       av_packet_unref(packet);
//     }
//   }
//   av_packet_free(&packet);
//   av_frame_free(&frame);
//   pcm_buffer.set_decoding_finished();
//   return 0;
// }